import { defineStore } from 'pinia'
import { ref } from 'vue'
import type { RouteRecordRaw } from 'vue-router'
import { asyncRoutes, constantRoutes } from '@/router/routes'
import { useAuthStore } from './auth'

/**
 * 检查用户是否有权限访问某个路由。
 * 
 * @param functionNames 后端返回的功能名称列表，如 ['客户档案', '宠物档案']
 * @param route 需要检查的路由对象
 */
function hasPermission(functionNames: string[], route: RouteRecordRaw): boolean {
  console.log(`检查路由权限: ${route.name} - 路由元数据:`, route.meta);

  // 如果是首页或404页面，所有用户都可以访问
  if (route.path === '/home' || route.path === '/404') {
    console.log(`路由 ${route.name} 是公共路由，所有用户都可以访问`);
    return true;
  }

  // 如果路由设置了 hidden: true，则不在菜单中显示，但仍然可以访问
  // 这些路由通常是表单页面，需要根据其父级路由的权限来判断
  if (route.meta?.hidden) {
    console.log(`路由 ${route.name} 设置了 hidden: true，检查父级权限`);
    
    // 对于表单路由，我们需要检查用户是否有对应模块的权限
    // 例如：/users/add 和 /users/update/:id 需要检查是否有 '客户档案' 权限
    const pathSegments = route.path.split('/');
    if (pathSegments.length >= 2) {
      const modulePath = pathSegments[1]; // 获取模块路径，如 'users', 'pets' 等
      
      // 定义模块路径与功能名称的映射关系
      const modulePermissionMap: Record<string, string[]> = {
        'users': ['客户档案'],
        'pets': ['宠物档案'],
        'services': ['服务项目'],
        'staffs': ['服务人员'],
        'resources': ['服务资源'],
        'appointments': ['预约记录'],
        'medical': ['疾病史'],
        'checkups': ['体检记录'],
        'vaccine': ['疫苗接种记录'],
        'dewormings': ['驱虫记录'],
        'service-records': ['服务记录']
      };
      
      const requiredPermissions = modulePermissionMap[modulePath];
      if (requiredPermissions) {
        // 检查用户是否有对应模块的权限
        const hasModulePermission = requiredPermissions.some(permission => 
          functionNames.includes(permission)
        );
        
        console.log(`表单路由 ${route.name} 需要模块权限: ${requiredPermissions.join(', ')}, 用户权限: ${functionNames.join(', ')}, 结果: ${hasModulePermission ? '有权限' : '无权限'}`);
        
        return hasModulePermission;
      }
    }
    
    // 如果没有找到对应的模块权限映射，默认允许访问
    console.log(`路由 ${route.name} 没有找到对应的模块权限映射，默认允许访问`);
    return true;
  }

  // 如果功能名称列表为空，则不允许访问任何需要权限的路由
  if (!functionNames || functionNames.length === 0) {
    console.log(`功能名称列表为空，拒绝访问路由: ${route.name}`);
    return false;
  }

  // 使用路由的name来匹配后端返回的功能名称列表
  if (route.name) {
    const routeName = route.name.toString();
    const routeTitle = route.meta?.title?.toString() || '';
    
    // 尝试多种匹配方式
    // 1. 直接匹配路由名称
    const directNameMatch = functionNames.some(fn => fn === routeName);
    
    // 2. 直接匹配路由标题
    const directTitleMatch = routeTitle && functionNames.some(fn => fn === routeTitle);
    
    // 3. 忽略大小写匹配
    const caseInsensitiveMatch = functionNames.some(
      fn => fn.toLowerCase() === routeName.toLowerCase() || 
            (routeTitle && fn.toLowerCase() === routeTitle.toLowerCase())
    );
    
    // 4. 部分匹配（如果功能名称是路由名称的一部分，或者路由名称是功能名称的一部分）
    const partialNameMatch = functionNames.some(
      fn => fn.includes(routeName) || routeName.includes(fn)
    );
    
    // 5. 部分匹配路由标题
    const partialTitleMatch = routeTitle && functionNames.some(
      fn => fn.includes(routeTitle) || routeTitle.includes(fn)
    );
    
    const hasAccess = directNameMatch || directTitleMatch || caseInsensitiveMatch || partialNameMatch || partialTitleMatch;
    
    console.log(`路由 ${routeName} (${routeTitle}) 权限检查:
      - 直接匹配名称: ${directNameMatch}
      - 直接匹配标题: ${directTitleMatch}
      - 忽略大小写匹配: ${caseInsensitiveMatch}
      - 部分匹配名称: ${partialNameMatch}
      - 部分匹配标题: ${partialTitleMatch}
      - 最终结果: ${hasAccess ? '有权限' : '无权限'}`
    );
    
    return hasAccess;
  }
  
  console.log(`路由没有name属性: ${JSON.stringify(route.path)}`);
  return false;
}

/**
 * 过滤异步路由，只保留用户有权访问的路由。
 * 
 * @param routes 所有的异步路由
 * @param functionNames 后端返回的功能名称列表
 */
export function filterAsyncRoutes(routes: RouteRecordRaw[], functionNames: string[]): RouteRecordRaw[] {
  console.log('开始过滤路由，功能名称列表:', functionNames)
  console.log('待过滤的路由:', routes.map(route => ({ name: route.name, path: route.path, hidden: route.meta?.hidden })))
  
  const accessedRoutes: RouteRecordRaw[] = []

  routes.forEach(route => {
    const tmpRoute = { ...route }
    
    // 检查路由权限
    if (hasPermission(functionNames, tmpRoute)) {
      accessedRoutes.push(tmpRoute)
      console.log(`✅ 路由 ${tmpRoute.name} (${tmpRoute.path}) 权限检查通过`)
    } else {
      console.log(`❌ 路由 ${tmpRoute.name} (${tmpRoute.path}) 权限检查失败`)
    }
  })

  console.log('过滤后的路由:', accessedRoutes.map(route => ({ name: route.name, path: route.path, hidden: route.meta?.hidden })))
  
  // 特别检查表单路由是否被包含
  const formRoutes = accessedRoutes.filter(route => route.meta?.hidden)
  console.log('包含的表单路由:', formRoutes.map(route => ({ name: route.name, path: route.path })))
  
  return accessedRoutes
}

export const usePermissionStore = defineStore('permission', () => {
  const routes = ref<RouteRecordRaw[]>([])
  const addRoutes = ref<RouteRecordRaw[]>([])

  /**
   * 根据后端返回的功能名称列表生成可访问的路由。
   */
  async function generateRoutes(): Promise<RouteRecordRaw[]> {
    const authStore = useAuthStore()
    
    // 从用户信息中获取功能名称列表
    const functionNames = authStore.user?.permissions || []
    
    console.log('后端返回的功能名称列表:', functionNames)
    console.log('用户信息:', authStore.user)
    console.log('所有异步路由:', asyncRoutes.map(route => ({ name: route.name, path: route.path })))
    
    return new Promise(resolve => {
      // 根据功能名称过滤异步路由
      const accessedRoutes = filterAsyncRoutes(asyncRoutes, functionNames)
      
      console.log('过滤后的路由:', accessedRoutes.map(route => ({ name: route.name, path: route.path })))
      
      // 将过滤后的异步路由和公共路由合并
      routes.value = constantRoutes.concat(accessedRoutes)
      addRoutes.value = accessedRoutes
      
      console.log('最终路由列表:', routes.value.map(route => ({ name: route.name, path: route.path })))
      
      resolve(accessedRoutes)
    })
  }

  return { routes, addRoutes, generateRoutes }
}) 